SuiteQL Query Tool
Learning Edition Guide

Welcome to the Learning Edition of the SuiteQL Query Tool. This guide will help you navigate the codebase and understand the key SuiteScript concepts demonstrated throughout the application.

Quick Start: Your First 5 Minutes

Want to see something working right away? Here's the fastest path to understanding how this tool works.

Step 1: Run Your First Query

Open the SuiteQL Query Tool and paste this simple query into the editor:

SELECT
    ID,
    CompanyName,
    Email
FROM
    Customer
WHERE
    ROWNUM <= 10

Click Run (or press Ctrl+Enter). You should see 10 customer records appear in the results.

Step 2: Understand What Happened

Here's what just occurred behind the scenes:

1. Your browser sent a POST request to the Suitelet with the query text
2. The Suitelet's handlePostRequest() function received it
3. It called executeQuery() which used query.runSuiteQL() to execute your SQL
4. NetSuite returned the data, which was sent back as JSON
5. The browser JavaScript rendered the results in the table

Step 3: Find This in the Code

Open suiteql-query-tool.v2026.01.suitelet-learning.js and search for:

• SECTION 4: QUERY EXECUTION - Where the query runs on the server
• query.runSuiteQL - The actual NetSuite API call
• function runQueryWithText - The client-side JavaScript that sends the request

Step 4: Try Modifying

Now experiment! Try these modifications:

• Change Customer to Vendor or Employee
• Add more columns: Phone, DateCreated
• Change ROWNUM <= 10 to ROWNUM <= 25
• Add a filter: AND IsInactive = 'F'

Purpose of the Learning Edition

The Learning Edition is a fully-annotated version of the SuiteQL Query Tool, designed to help developers learn SuiteScript development through a real-world, production-quality application.

Who Is This For?

• JavaScript developers new to NetSuite who want to understand SuiteScript
• NetSuite administrators looking to expand into development
• SuiteScript beginners who want to see patterns beyond "Hello World" examples
• Experienced developers looking for reference implementations of common patterns

What You'll Learn

• How to build custom user interfaces with Suitelets
• Executing SuiteQL queries with the N/query module
• File Cabinet operations with the N/file module
• Making external API calls with the N/https module
• Generating PDFs with the N/render module
• Session management and runtime information
• Client-server communication patterns
• Governance management and best practices

SuiteScript Primer

Before diving into the code, here's a quick overview of SuiteScript fundamentals.

What is SuiteScript?

SuiteScript is NetSuite's server-side JavaScript API. It allows you to customize and extend NetSuite's functionality through scripts that run on NetSuite's servers. SuiteScript 2.x (the current version) uses the AMD module pattern and supports modern JavaScript features.

Script Types

NetSuite has several script types, each designed for specific use cases:

The SuiteQL Query Tool is a Suitelet, which makes it perfect for building custom web applications inside NetSuite.

The N/ Module System

SuiteScript functionality is organized into modules prefixed with "N/". You import these modules using the AMD define() function:

define([
    'N/query',      // SuiteQL queries
    'N/file',       // File Cabinet operations
    'N/runtime'     // Script/user/session info
], function(query, file, runtime) {
    // Your code here
    return {
        onRequest: myFunction
    };
});

Governance

Every SuiteScript operation consumes "governance units." Each script type has a limit:

Application Architecture

The SuiteQL Query Tool follows a client-server architecture where a single Suitelet serves both the HTML user interface and a JSON API.

Request Flow Diagram

┌─────────────────────────────────────────────────────────────────────┐
│                         USER'S BROWSER                               │
└─────────────────────────────────────────────────────────────────────┘
        │                                          ▲
        │ 1. GET request                           │ 2. HTML page with
        │    (initial page load)                   │    embedded JavaScript
        ▼                                          │
┌─────────────────────────────────────────────────────────────────────┐
│                           SUITELET                                   │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │  onRequest(context)                                          │    │
│  │    ├── GET  → handleGetRequest()  → serverWidget form        │    │
│  │    └── POST → handlePostRequest() → JSON response            │    │
│  └─────────────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────────────┘
        ▲                                          │
        │ 3. AJAX POST                             │ 4. JSON data
        │    { function: 'queryExecute', ... }     │    { records: [...] }
        │                                          ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    BROWSER JAVASCRIPT (SQT)                          │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐     │
│  │ runQuery()      │  │ loadSqlFile()   │  │ generateAI()    │     │
│  │ → fetch() POST  │  │ → fetch() POST  │  │ → fetch() POST  │     │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘     │
└─────────────────────────────────────────────────────────────────────┘

Key Architectural Concepts

1. Dual-Purpose Suitelet

The Suitelet handles two types of requests:

• GET requests return the full HTML page (the UI)
• POST requests act as API endpoints, returning JSON

2. INLINEHTML for Custom UI

Instead of using NetSuite's built-in form widgets, we inject a complete custom HTML application using the INLINEHTML field type. This gives us full control over the user interface.

3. Client-Side JavaScript

The embedded JavaScript runs in the browser (not as SuiteScript). It uses standard web APIs like fetch() to communicate with the server. This is regular JavaScript with access to the DOM, localStorage, and third-party libraries.

4. Handler Dispatch Pattern

POST requests include a function property that tells the server which operation to perform. The server uses a dispatch table to route requests:

const handlers = {
    'queryExecute': () => executeQuery(context, payload),
    'sqlFileLoad':  () => loadSqlFile(context, payload),
    'sqlFileSave':  () => saveSqlFile(context, payload),
    // ... more handlers
};

const handler = handlers[payload.function];
if (handler) handler();

Code Roadmap

The Learning Edition script is organized into numbered sections. Here's what each section contains:

Key Patterns to Study

These are the most instructive parts of the codebase for learning SuiteScript:

Beginner Basic Query Execution

Location: Section 4, executeQuery() function

Learn how to execute SuiteQL queries and handle the results:

const records = modules.query.runSuiteQL({
    query: 'SELECT ID, CompanyName FROM Customer WHERE IsInactive = ?',
    params: ['F']  // Parameterized query - prevents SQL injection!
}).asMappedResults();  // Returns array of objects

Beginner File Cabinet Operations

Location: Section 5, loadSqlFile() and saveSqlFile()

Learn how to read and write files in NetSuite's File Cabinet:

// Loading a file
const fileObj = modules.file.load({ id: fileId });
const contents = fileObj.getContents();

// Creating a file
const newFile = modules.file.create({
    name: 'query.sql',
    contents: sqlText,
    folder: folderId,
    fileType: modules.file.Type.PLAINTEXT
});
const savedId = newFile.save();

Intermediate External API Calls

Location: Section 6.5, callAnthropicAPI() and callOpenAIAPI()

Learn how to make HTTPS requests to external services:

const response = modules.https.post({
    url: 'https://api.example.com/endpoint',
    headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer ' + apiKey
    },
    body: JSON.stringify(requestData)
});

if (response.code === 200) {
    const data = JSON.parse(response.body);
}

Intermediate Session Storage

Location: Section 7, submitDocument() and generateDocument()

Learn how to persist data across requests within a user's session:

// Storing data
const session = modules.runtime.getCurrentSession();
session.set({
    name: 'myData',
    value: JSON.stringify(dataObject)
});

// Retrieving data (in a later request)
const stored = session.get({ name: 'myData' });
const data = JSON.parse(stored);

Intermediate PDF Generation

Location: Section 7, generateDocument()

Learn how to generate PDFs from templates with dynamic data:

const renderer = modules.render.create();
renderer.addCustomDataSource({
    alias: 'data',
    format: modules.render.DataSource.OBJECT,
    data: { records: queryResults }
});
renderer.templateContent = xmlTemplate;
const pdfFile = renderer.renderAsPdf();

Advanced Query Pagination

Location: Section 4, executePaginatedQuery()

Learn how to retrieve more than SuiteQL's 5,000 row limit:

// Wrap query with ROWNUM for pagination
const paginatedSql = `
    SELECT * FROM (
        SELECT ROWNUM AS ROWNUMBER, * FROM (${originalQuery})
    ) WHERE ROWNUMBER BETWEEN ${start} AND ${end}
`;

Advanced Custom UI Architecture

Location: Section 9, generateMainHtml() and generateClientScript()

Learn the pattern for building single-page applications inside Suitelets using INLINEHTML, including client-server communication with fetch().

Suggested Learning Path

Here's a recommended order for exploring the codebase:

Phase 1: Understand the Structure

1. Read the JSDoc decorators at the top of the file
2. Study the define() call and module imports (Section 2)
3. Understand the onRequest entry point and how it routes GET vs POST

Phase 2: Learn Core Operations

1. Study executeQuery() - this is the heart of the application
2. Explore file operations - loading and saving SQL files
3. Understand handlePostRequest() and the dispatch pattern

Phase 3: Advanced Patterns

1. Study external API calls in the AI generation section
2. Explore PDF generation with the render module
3. Understand session storage for multi-step processes

Phase 4: UI Architecture

1. See how INLINEHTML is used to inject custom HTML
2. Study the client-side JavaScript and its communication with the server
3. Understand the fetch() pattern for AJAX calls

Glossary of NetSuite Terms

NetSuite has its own vocabulary. Here are key terms you'll encounter:

Deployment Walkthrough

Here's how to deploy the SuiteQL Query Tool (or any Suitelet) to NetSuite:

Step 1: Upload the Script File

1. Go to Documents > Files > File Cabinet
2. Navigate to SuiteScripts folder (create it if it doesn't exist)
3. Click Add File and upload suiteql-query-tool.v2026.01.suitelet.js
4. Note the file's location path (e.g., SuiteScripts/suiteql-query-tool.v2026.01.suitelet.js)

Step 2: Create the Script Record

1. Go to Customization > Scripting > Scripts > New
2. Select the uploaded script file
3. NetSuite will detect it as a Suitelet and pre-fill the type
4. Fill in the script record:
   • Name: SuiteQL Query Tool
   • ID: _suiteql_query_tool (NetSuite adds customscript prefix)
   • Description: A modern utility for running SuiteQL queries
5. Click Save

Step 3: Create a Deployment

1. On the Script record, go to the Deployments subtab
2. Click New Deployment
3. Fill in the deployment:
   • Title: SuiteQL Query Tool
   • ID: _suiteql_query_tool (NetSuite adds customdeploy prefix)
   • Status: Released (or Testing for initial setup)
   • Log Level: Debug (for development) or Error (for production)
   • Execute As Role: Usually "Current Role" for Suitelets
4. On the Audience subtab, select which roles can access the Suitelet
5. Click Save

Step 4: Access the Suitelet

After saving the deployment, you can access the Suitelet via:

• Direct URL: Click the URL link on the deployment record
• Custom Menu: Add it to a center tab or custom menu for easy access

Step 5: (Optional) Add to Navigation

To add a menu item for easy access:

1. Go to Customization > Centers and Tabs > Center Links
2. Create a new link pointing to your Suitelet URL
3. Assign it to the appropriate center (e.g., Reports, Setup)

Common Errors & Troubleshooting

Here are errors you'll commonly encounter and how to resolve them:

SSS_USAGE_LIMIT_EXCEEDED

Cause: Your script used more governance units than its limit allows.

Solutions:

• Reduce the number of operations (fewer queries, fewer record loads)
• Use runtime.getCurrentScript().getRemainingUsage() to monitor usage
• For large operations, use Map/Reduce scripts (10,000 units per phase)
• Batch operations instead of processing one record at a time

SSS_INVALID_SRCH_COLUMN / Invalid Column

Cause: The column doesn't exist on the table, or you don't have permission to access it.

Solutions:

• Check the column name in the Analytics Browser (Records Catalog)
• Verify your role has permission to view that field
• Column names are case-sensitive in some contexts
• Use BUILTIN.DF() for reference fields if you want the display value

SSS_INVALID_SRCH_FILTER / Invalid Table

Cause: The table doesn't exist or you don't have permission to access it.

Solutions:

• Verify the table name in the Analytics Browser
• Check if it's a custom record (should be customrecord_xxx)
• Ensure your role has permission to view records of that type

UNEXPECTED_ERROR

Cause: A generic error, often from malformed queries or server issues.

Solutions:

• Check your SQL syntax carefully (missing quotes, parentheses)
• Try simplifying the query to isolate the problem
• Check the Execution Log for more details
• Verify all referenced tables and columns exist

Search Timed Out

Cause: The query took too long to execute (usually over 3-5 minutes).

Solutions:

• Add more restrictive WHERE clauses (date ranges, specific IDs)
• Remove unnecessary JOINs
• Avoid SELECT * - only select columns you need
• Add indexes via custom fields if querying frequently on specific columns
• Consider using a Saved Search or Workbook for very complex reports

INVALID_API_KEY / Authentication Errors (AI Features)

Cause: The AI API key is incorrect, expired, or has insufficient permissions.

Solutions:

• Verify the API key is correct (no extra spaces)
• Check if the key has expired or been revoked
• Ensure the key has the necessary permissions/credits
• For OpenAI: Verify you have API credits available

File Not Found / Load Error

Cause: Trying to load a file that doesn't exist or was deleted.

Solutions:

• Verify the file ID or path is correct
• Check if the file was moved or deleted
• Ensure your role has permission to access the file's folder

SuiteQL Quick Reference

A handy reference for common SuiteQL patterns and syntax.

Common Tables

Transaction Type Codes

Use these in WHERE Transaction.type = 'xxx':

Useful Functions

-- Get display value instead of internal ID
BUILTIN.DF( Transaction.status ) AS StatusName

-- Handle NULL values
NVL( Customer.phone, 'No Phone' ) AS Phone

-- Date formatting
TO_CHAR( Transaction.trandate, 'YYYY-MM-DD' ) AS FormattedDate

-- Date parsing
TO_DATE( '2024-01-15', 'YYYY-MM-DD' )

-- Current date
SYSDATE

-- Date arithmetic
ADD_MONTHS( SYSDATE, -3 )  -- 3 months ago
TRUNC( SYSDATE )           -- Today at midnight

-- String functions
UPPER( Customer.companyname )
LOWER( Customer.email )
SUBSTR( Item.itemid, 1, 3 )
CONCAT( firstname, CONCAT( ' ', lastname ) )

-- Conditional logic
CASE
    WHEN amount > 1000 THEN 'Large'
    WHEN amount > 100 THEN 'Medium'
    ELSE 'Small'
END AS SizeCategory

-- Aggregates
COUNT( * ), SUM( amount ), AVG( rate ), MIN( trandate ), MAX( trandate )

Common Query Patterns

Basic SELECT with JOIN

SELECT
    Transaction.tranid,
    Transaction.trandate,
    BUILTIN.DF( Transaction.entity ) AS CustomerName,
    Transaction.total
FROM
    Transaction
    INNER JOIN Customer ON Customer.id = Transaction.entity
WHERE
    Transaction.type = 'SalesOrd'
    AND Transaction.trandate >= TO_DATE( '2024-01-01', 'YYYY-MM-DD' )
ORDER BY
    Transaction.trandate DESC

Transaction with Lines

SELECT
    Transaction.tranid,
    TransactionLine.linesequencenumber,
    BUILTIN.DF( TransactionLine.item ) AS ItemName,
    TransactionLine.quantity,
    TransactionLine.rate,
    TransactionLine.amount
FROM
    Transaction
    INNER JOIN TransactionLine ON TransactionLine.transaction = Transaction.id
WHERE
    Transaction.id = 12345

Aggregate with GROUP BY

SELECT
    BUILTIN.DF( Transaction.status ) AS Status,
    COUNT( * ) AS OrderCount,
    SUM( Transaction.total ) AS TotalAmount
FROM
    Transaction
WHERE
    Transaction.type = 'SalesOrd'
GROUP BY
    BUILTIN.DF( Transaction.status )
ORDER BY
    OrderCount DESC

Limiting Results (No LIMIT keyword!)

SELECT * FROM (
    SELECT
        Customer.id,
        Customer.companyname
    FROM
        Customer
    ORDER BY
        Customer.datecreated DESC
)
WHERE ROWNUM <= 10

Security Best Practices

Security is critical when building NetSuite applications. Follow these practices:

1. Always Use Parameterized Queries

Never concatenate user input directly into SQL strings. Use the params array:

// GOOD - Parameterized (safe)
const results = query.runSuiteQL({
    query: 'SELECT * FROM Customer WHERE id = ?',
    params: [customerId]
}).asMappedResults();

// BAD - String concatenation (SQL injection risk!)
const results = query.runSuiteQL({
    query: 'SELECT * FROM Customer WHERE id = ' + customerId
}).asMappedResults();

2. Never Expose API Keys in Client-Side Code

API keys should be:

• Stored in Script Parameters (configured in the deployment record)
• Entered by users and stored in their session (like this tool does)
• Never hard-coded in JavaScript that runs in the browser

3. Be Careful with isOnline Files

When creating files with file.create():

const fileObj = modules.file.create({
    name: 'report.pdf',
    contents: pdfContents,
    folder: folderId,
    fileType: modules.file.Type.PDF,
    isOnline: false  // IMPORTANT: Keep files private!
});

Setting isOnline: true makes the file publicly accessible without authentication. Only use this for intentionally public files.

4. Validate and Sanitize Input

Always validate data from external sources:

// Validate expected data types
if (typeof payload.customerId !== 'number') {
    throw new Error('Invalid customer ID');
}

// Validate against allowed values
const allowedTypes = ['SalesOrd', 'Invoice', 'PurchOrd'];
if (!allowedTypes.includes(payload.transactionType)) {
    throw new Error('Invalid transaction type');
}

5. Use Appropriate Role Permissions

• Deploy scripts with the minimum necessary permissions
• Use "Execute As Role" carefully - it can elevate privileges
• Restrict Suitelet access to specific roles in the deployment's Audience tab

6. Log Sensitive Operations

Use log.audit() for security-relevant events:

modules.log.audit({
    title: 'Sensitive Operation',
    details: `User ${runtime.getCurrentUser().id} exported ${records.length} customer records`
});

Debugging Tips

Effective debugging is essential for SuiteScript development. Here are key techniques:

1. Use the Execution Log

The N/log module writes to NetSuite's Execution Log:

// Different log levels
log.debug({ title: 'Debug Info', details: myVariable });
log.audit({ title: 'Important Event', details: 'User clicked submit' });
log.error({ title: 'Error Occurred', details: e.message });

// Log objects (automatically stringified)
log.debug({ title: 'Query Results', details: records });

// Log governance usage
log.debug({
    title: 'Governance Check',
    details: 'Remaining: ' + runtime.getCurrentScript().getRemainingUsage()
});

To view logs: Go to the Script Deployment record → click View Execution Log

2. Use Browser Developer Tools for Client-Side Code

For JavaScript running in the browser (inside INLINEHTML):

• Console: Use console.log() for debugging
• Network tab: Inspect AJAX requests and responses
• Sources tab: Set breakpoints in your code
• Application tab: Inspect localStorage values

3. Isolate the Problem

When debugging complex queries or operations:

• Comment out sections to find what's failing
• Simplify queries (remove JOINs, reduce columns)
• Test with known good values first
• Check the Execution Log for detailed error messages

4. Common Debugging Patterns

Log Before and After

log.debug({ title: 'Before Query', details: { query: sql, params: params } });
const results = query.runSuiteQL({ query: sql, params: params }).asMappedResults();
log.debug({ title: 'After Query', details: { count: results.length } });

Wrap in Try/Catch with Logging

try {
    // Your code here
} catch (e) {
    log.error({
        title: 'Error in myFunction',
        details: {
            message: e.message,
            name: e.name,
            stack: e.stack
        }
    });
    throw e;  // Re-throw if needed
}

Conditional Logging

const DEBUG = true;  // Set to false in production

if (DEBUG) {
    log.debug({ title: 'Detailed Debug', details: bigObject });
}

5. Test in Sandbox First

Always test scripts in a Sandbox account before deploying to production:

• Sandboxes are copies of your production data
• Mistakes won't affect real data
• You can test with realistic data volumes

6. Use the Script Debugger

NetSuite has a built-in debugger for server-side SuiteScript:

1. On your script record, check Enable Script Debugger
2. Go to Customization > Scripting > Script Debugger
3. Trigger your script and step through the code

Frequently Asked Questions

SuiteQL Questions

Q: Why can't I use LIMIT like in MySQL?

A: SuiteQL is based on Oracle SQL, which doesn't have a LIMIT keyword. Use ROWNUM instead:

-- Get first 10 rows
SELECT * FROM Customer WHERE ROWNUM <= 10

-- For pagination (rows 11-20), wrap in subquery
SELECT * FROM (
    SELECT ROWNUM AS rn, c.* FROM Customer c
) WHERE rn BETWEEN 11 AND 20

Q: How do I find table and column names?

A: Several options:

• Analytics Browser: In NetSuite, go to Analytics > Analytics Browser (or search "Records Catalog")
• Tables Reference: Use the Tables button in the SuiteQL Query Tool
• Query the metadata: SELECT * FROM OA_TABLES WHERE ROWNUM <= 100
• NetSuite Help: Search for "SuiteQL Supported Records" in NetSuite Help

Q: Why is my query slow?

A: Common causes and fixes:

• No WHERE clause: Always filter data - don't query entire tables
• SELECT *: Only select columns you need
• Missing date range: Add trandate BETWEEN x AND y for transactions
• Too many JOINs: Each JOIN multiplies complexity
• Functions on indexed columns: WHERE UPPER(name) = 'X' can't use indexes

Q: Why do I get numbers instead of names for some fields?

A: Reference fields (foreign keys) store internal IDs. Use BUILTIN.DF() to get the display value:

-- Returns ID like "42"
SELECT status FROM Transaction

-- Returns name like "Pending Fulfillment"
SELECT BUILTIN.DF(status) AS StatusName FROM Transaction

Q: Can I INSERT, UPDATE, or DELETE with SuiteQL?

A: No. SuiteQL is read-only. To modify data, use the N/record module:

const rec = record.load({ type: 'customer', id: 123 });
rec.setValue({ fieldId: 'phone', value: '555-1234' });
rec.save();

SuiteScript Questions

Q: What's the difference between SuiteScript 1.0 and 2.x?

A: SuiteScript 2.x (current) uses modern JavaScript with AMD modules. Key differences:

Q: How do I know if I'm running out of governance?

A: Check remaining units with:

const remaining = runtime.getCurrentScript().getRemainingUsage();
log.debug('Governance remaining', remaining);

// Bail out if running low
if (remaining < 100) {
    throw new Error('Low governance - stopping early');
}

Q: Can I use npm packages in SuiteScript?

A: Not directly. SuiteScript runs in NetSuite's environment, not Node.js. However:

• Some libraries work if they're pure JavaScript (no Node APIs)
• You can bundle with tools like Webpack (advanced)
• For common needs, check if NetSuite has a built-in module first

Q: How do I schedule a script to run automatically?

A: Create a Scheduled Script:

1. Set @NScriptType ScheduledScript in your file
2. Implement the execute function
3. Deploy and set a schedule (daily, hourly, etc.) on the deployment record

Tool-Specific Questions

Q: Where are my queries saved?

A: Query history is stored in your browser's localStorage. It persists across sessions but is specific to your browser and device. Clearing browser data will erase history.

Q: Can I share queries with colleagues?

A: Yes! Use the Share button to generate a URL that includes your query. Anyone with access to the tool can open that URL and see your query.

Q: Why do I need an API key for AI features?

A: The AI features use external services (Anthropic Claude or OpenAI). You provide your own API key, which keeps costs transparent and data under your control. Keys are stored in your browser session, not on NetSuite servers.

Printable Cheat Sheet

A condensed reference you can print and keep nearby. (Tip: Use your browser's Print function and select "Print selection" if available.)

BUILTIN.DF(field)     -- Display value
NVL(field, default)   -- Handle NULL
TO_DATE('2024-01-01', 'YYYY-MM-DD')
TO_CHAR(date, 'YYYY-MM-DD')
SYSDATE               -- Current date
ROWNUM                -- Row limiter

SELECT
  t.tranid,
  BUILTIN.DF(t.entity) AS Name
FROM Transaction t
WHERE t.type = 'SalesOrd'
  AND t.trandate >= TO_DATE(...)
ORDER BY t.trandate DESC

Additional Resources

Official Documentation

• SuiteScript 2.x API Reference
• SuiteQL Documentation
• N/query Module
• N/file Module
• N/https Module
• N/render Module

SuiteQL Resources

• SuiteQL Query Syntax
• Analytics Browser (Table Reference)
• Tim Dietrich's SuiteQL Blog Posts

Community Resources

• Stack Overflow - SuiteScript Tag
• r/NetSuite on Reddit
• NetSuite Customer Support

Tools

• NetSuite Field Explorer (Chrome Extension)
• SuiteCloud CLI for Node.js